// 导出插件入口函数 - 必须放在文件最顶部
if (typeof module !== 'undefined' && module.exports) {
    module.exports = function() {
        console.log('信息更新插件已加载');
        return {
            name: 'info-update',
            description: '信息更新工具集'
        };
    };
}

// 浏览器环境代码 - 只在浏览器环境中执行
if (typeof window !== 'undefined') {
    const { createApp, ref } = Vue;
    const { ElMessage } = ElementPlus;

    // ElMessage挂载全局
    window.ElMessage = ElMessage;
    const app = createApp({});
    app.use(ElementPlus);
    app.mount('#app');

    // 获取进度条元素
    const progressContainer = document.getElementById('progressContainer');
    const progressBar = document.getElementById('progressBar');

    // 更新进度条函数
    function updateProgress(percent, show = true) {
        if (show) {
            progressContainer.style.display = 'block';
        } else {
            progressContainer.style.display = 'none';
            return;
        }
        
        progressBar.style.width = `${percent}%`;
    }

    // 定义响应式变量
    const isHeadless = ref(false);
    const selectedTab = ref('cfr-scraper');

    // 从 DOM 获取元素
    const headlessSwitchElement = document.getElementById('headless-switch');
    const startBtn = document.getElementById('startBtn');
    const stopBtn = document.getElementById('stopBtn');
    const resultsEl = document.getElementById('results');
    const logEl = document.getElementById('log');

    // 处理操作步骤显示/隐藏切换
    function handleStepsSwitch() {
        console.log(`操作步骤已 ${isHeadless.value ? '隐藏' : '显示'}`);
        // 使用ElMessage向用户提示操作步骤切换状态
        ElMessage.info(`操作步骤已${isHeadless.value ? '隐藏' : '显示'}，${isHeadless.value ? '将隐藏自动化操作过程' : '将展示自动化操作过程'}`);
    }

    // 绑定事件
    if (headlessSwitchElement) {
        headlessSwitchElement.addEventListener('change', function() {
            isHeadless.value = headlessSwitchElement.checked;
            handleStepsSwitch();
        });
    }

    // CEN相关变量和元素
    const cenHeadlessSwitch = document.getElementById('cen-headless-switch');
    const cenStartBtn = document.getElementById('cen-start-btn');
    const cenStopBtn = document.getElementById('cen-stop-btn');
    const cenExportBtn = document.getElementById('cen-export-btn');
    const cenResults = document.getElementById('cen-results');
    const cenLog = document.getElementById('cen-log');
    const cenProgressContainer = document.getElementById('cen-progress-container');
    const cenProgressBar = document.getElementById('cen-progress-bar');
    const cenProgressText = document.getElementById('cen-progress-text');
    
    let cenIsHeadless = false;
    let cenScrapingProcess = null;
    let cenFilteredData = [];
    let cenConsoleLogListener = null;
    
    // 目标TC号码列表
    const targetTCs = [
        'CEN/TC 33', 'CEN/TC 49', 'CEN/TC 52', 'CEN/TC 67', 'CEN/TC 93',
        'CEN/TC 114', 'CEN/TC 136', 'CEN/TC 158', 'CEN/TC 162', 'CEN/TC 163',
        'CEN/TC 194', 'CEN/TC 207', 'CEN/TC 217', 'CEN/TC 252', 'CEN/TC 255',
        'CEN/TC 333', 'CEN/TC 355', 'CEN/TC 364', 'CEN/TC 369', 'CEN/TC 402'
    ];
    
    // CEN浏览器模式切换
    if (cenHeadlessSwitch) {
        cenHeadlessSwitch.addEventListener('change', function() {
            cenIsHeadless = cenHeadlessSwitch.checked;
            addCenLog(`浏览器模式已切换为: ${cenIsHeadless ? '显示' : '隐藏'}`, 'info');
        });
    }

    // 添加日志函数
    function addLog(message, type = 'info') {
        if (!logEl) return;
        
        const timestamp = new Date().toLocaleTimeString();
        let logClass = '';
        
        // 根据日志类型添加不同的样式
        switch(type.toLowerCase()) {
            case 'error':
                logClass = 'log-error';
                break;
            case 'warning':
                logClass = 'log-warning';
                break;
            case 'success':
                logClass = 'log-success';
                break;
            default:
                logClass = 'log-info';
        }
        
        // 添加带样式的日志条目
        logEl.innerHTML += `<div class="${logClass}">[${timestamp}] ${message}</div>`;
        logEl.scrollTop = logEl.scrollHeight;
    }
    
    // CEN日志函数
    function addCenLog(message, type = 'info') {
        if (!cenLog) return;
        
        const timestamp = new Date().toLocaleTimeString();
        let logClass = '';
        
        switch(type.toLowerCase()) {
            case 'error':
                logClass = 'log-error';
                break;
            case 'warning':
                logClass = 'log-warning';
                break;
            case 'success':
                logClass = 'log-success';
                break;
            default:
                logClass = 'log-info';
        }
        
        cenLog.innerHTML += `<div class="${logClass}">[${timestamp}] ${message}</div>`;
        cenLog.scrollTop = cenLog.scrollHeight;
        
        // 同时发送到控制台监控系统
        if (typeof consoleAPI !== 'undefined') {
            consoleAPI.addConsoleLog(type, `CEN UI: ${message}`);
        }
    }
    
    // 初始化CEN控制台监控
    function initializeCenConsoleMonitoring() {
        console.log('CEN UI: 初始化控制台监控...');
        
        // 检查是否存在控制台API
        if (typeof consoleAPI !== 'undefined') {
            console.log('CEN UI: 找到控制台API，开始监控');
            
            // 设置控制台日志监听器
            cenConsoleLogListener = (log) => {
                displayCenConsoleLog(log);
            };
            
            // 开始监听控制台日志
            consoleAPI.onConsoleLog(cenConsoleLogListener);
            
            // 开始控制台监控
            consoleAPI.startConsoleMonitoring();
            
            console.log('CEN UI: 控制台监控已启动');
        } else {
            console.warn('CEN UI: 控制台API不可用，使用本地日志');
        }
    }
    
    // 显示CEN控制台日志
    function displayCenConsoleLog(log) {
        if (!cenLog) return;
        
        // 过滤只显示相关的日志（包含CEN相关关键词）
        const message = log.message || '';
        const isRelevant = message.includes('CEN') || 
                          message.includes('cen') || 
                          message.includes('正在导入') ||
                          message.includes('浏览器') ||
                          message.includes('页面') ||
                          message.includes('抓取') ||
                          message.includes('标准') ||
                          message.includes('处理') ||
                          message.includes('获取');
        
        if (isRelevant) {
            const timestamp = new Date(log.timestamp).toLocaleTimeString();
            const logEntry = document.createElement('div');
            logEntry.className = `log-entry log-${log.level || 'info'}`;
            logEntry.innerHTML = `<span class="timestamp">[${timestamp}]</span> ${message}`;
            
            cenLog.appendChild(logEntry);
            cenLog.scrollTop = cenLog.scrollHeight;
        }
    }
    
    // 清理CEN控制台监听器
    function cleanupCenConsoleMonitoring() {
        if (cenConsoleLogListener && typeof consoleAPI !== 'undefined') {
            consoleAPI.removeConsoleLogListeners();
            cenConsoleLogListener = null;
            console.log('CEN UI: 控制台监听器已清理');
        }
    }
    
    // CEN进度更新函数
    function updateCenProgress(percent, show = true) {
        if (!cenProgressContainer || !cenProgressBar || !cenProgressText) return;
        
        if (show) {
            cenProgressContainer.style.display = 'block';
            cenProgressBar.style.width = `${percent}%`;
            cenProgressText.textContent = `${percent}%`;
        } else {
            cenProgressContainer.style.display = 'none';
        }
    }

    // 更新状态函数
    function updateStatus(message, type = 'running') {
        const statusEl = document.getElementById('status');
        if (!statusEl) return;
        
        statusEl.textContent = message;
        statusEl.className = `status ${type}`;
        statusEl.style.display = 'block';
    }

    // 开始爬取函数
    async function startScraping() {
        console.log('开始执行startScraping函数');
        
        // 详细检查必要的DOM元素
        if (!startBtn) {
            console.error('startBtn元素不存在');
            addLog('错误: 开始按钮元素不存在', 'error');
            return;
        }
        
        if (!stopBtn) {
            console.error('stopBtn元素不存在');
            addLog('错误: 停止按钮元素不存在', 'error');
            return;
        }
        
        if (!resultsEl) {
            console.error('resultsEl元素不存在');
            addLog('错误: 结果显示区域元素不存在', 'error');
            return;
        }
        
        console.log('所有必要DOM元素已确认存在');
        
        startBtn.disabled = true;
        stopBtn.disabled = false;
        
        // 清空之前的日志
        if (logEl) {
            logEl.innerHTML = '';
        }
        
        // 获取用户选择的时间框架
        const timeframeSelect = document.getElementById('timeframeSelect');
        const selectedTimeframe = timeframeSelect ? timeframeSelect.value : 'Past 7 Days';
        
        updateStatus('正在启动浏览器...', 'running');
        addLog('开始执行信息更新任务', 'info');
        addLog(`选择的时间框架: ${selectedTimeframe}`, 'info');
        addLog('启动 Playwright 浏览器...', 'info');
        resultsEl.innerHTML = '<p style="text-align: center; color: #666;">搜索中，请稍候...</p>';
        updateProgress(10);
        
        // 存储Processing提示的引用，以便后续关闭
        let processingMessage = null;
        
        try {
            // 创建Processing提示
            processingMessage = ElMessage.info({
                message: 'Processing，please wait...',
                duration: 0,  // 设置为0表示不会自动关闭
                showClose: true  // 显示关闭按钮
            });
            
            // 更新进度条
            updateProgress(30);
            
            addLog('调用核心脚本处理数据...', 'info');
            console.log('调用核心脚本，参数:', { isHeadless: isHeadless.value, selectedTimeframe });
            
            const scriptParams = {
                pluginName: 'info-update',
                script: './govinfo/core.js',
                args: [isHeadless.value, selectedTimeframe]
            };
            
            console.log('核心脚本调用参数:', scriptParams);
            
            const result = await pluginAPI.runPluginScript(scriptParams);
            
            console.log('核心脚本返回结果:', result);
            console.log('返回结果类型:', typeof result);
            console.log('返回结果是否包含data字段:', result.hasOwnProperty('data'));
            
            if (result.data) {
                console.log('data字段类型:', typeof result.data);
                console.log('data是否为数组:', Array.isArray(result.data));
                if (Array.isArray(result.data)) {
                    console.log('data数组长度:', result.data.length);
                    console.log('data数组第一项:', result.data[0]);
                }
            }
            
            addLog('核心脚本执行完成', result.success ? 'success' : 'error');
            
            // 脚本执行完成后设置进度为80%
            updateProgress(80);
            
            if (result.success) {
                // 完成进度条
                updateProgress(100);
                
                // 关闭Processing提示
                if (processingMessage) {
                    processingMessage.close();
                }
                
                ElMessage.success({
                    message: 'Finished!',
                    duration: 3000  // 3秒后自动关闭
                });
                
                // 显示处理结果
                if (result.data) {
                    console.log('获取到数据:', result.data);
                    if (Array.isArray(result.data)) {
                        addLog(`成功获取 ${result.data.length} 条数据记录`, 'success');
                        console.log('准备调用displayResults函数显示数据');
                        displayResults(result.data);
                        
                        // 数据已在后端自动保存为JSON文件
                        console.log('数据已在后端自动保存为JSON文件');
                        addLog('数据已在后端自动保存为JSON文件', 'info');
                    } else {
                        console.error('返回的数据不是数组:', result.data);
                        addLog('返回的数据格式不正确，不是数组', 'warning');
                        displayResults([]);
                    }
                } else {
                    console.error('未获取到数据记录');
                    addLog('未获取到数据记录', 'warning');
                    displayResults([]);
                }
                
                // 延迟后隐藏进度条
                setTimeout(() => updateProgress(0, false), 1000);
            }
            if (!result.success) {
                console.error('执行失败:', result.error);
                addLog(`执行失败: ${result.error}`, 'error');
                throw new Error(result.error);
            }
        } catch (error) {
            // 出错时隐藏进度条
            updateProgress(0, false);
            
            // 关闭Processing提示
            if (processingMessage) {
                processingMessage.close();
            }
            
            console.error('发生错误:', error);
            addLog(`发生错误: ${error.message}`, 'error');
            
            ElMessage.error({
                message: 'Failed, Please check.',
                duration: 5000,  // 5秒后自动关闭
                showClose: true  // 显示关闭按钮
            });
            
            addLog(`搜索失败: ${error.message}`);
            updateStatus('搜索失败', 'error');
            resultsEl.innerHTML = '<p style="text-align: center; color: #d32f2f;">搜索失败，请查看日志</p>';
        } finally {
            // 重新启用按钮
            startBtn.disabled = false;
            stopBtn.disabled = true;
        }
    }

    // 停止爬取函数
async function stopScraping() {
    try {
        updateStatus('正在尝试停止搜索...', 'warning');
        addLog('用户请求停止搜索');
        
        // 调用pluginAPI.stopPluginScript方法停止脚本
        const taskId = pluginAPI.getCurrentTaskId();
        console.log(`当前任务ID: ${taskId || '无'}`);
        
        if (taskId) {
            console.log(`正在停止任务: ${taskId}`);
            addLog(`正在停止任务: ${taskId}`);
            const result = await pluginAPI.stopPluginScript();
            console.log('停止脚本结果:', result);
            
            if (result.success) {
                updateStatus('搜索已停止', 'success');
                addLog('搜索已成功停止', 'success');
                ElMessage.success({
                    message: '搜索已停止',
                    duration: 3000
                });
            } else {
                updateStatus('停止搜索失败', 'error');
                addLog(`停止搜索失败: ${result.error || '未知错误'}`, 'error');
                ElMessage.error({
                    message: `停止搜索失败: ${result.error || '未知错误'}`,
                    duration: 5000
                });
            }
        } else {
            console.warn('没有正在运行的搜索任务');
            updateStatus('没有正在运行的搜索任务', 'warning');
            addLog('没有找到正在运行的搜索任务', 'warning');
            ElMessage.warning({
                message: '没有正在运行的搜索任务',
                duration: 3000
            });
            
            // 即使没有任务，也重置按钮状态和隐藏进度条
            startBtn.disabled = false;
            stopBtn.disabled = true;
            updateProgress(0, false);
            return;
        }
    } catch (error) {
        console.error('停止搜索时发生错误:', error);
        updateStatus('停止搜索失败', 'error');
        addLog(`停止失败: ${error.message || '未知错误'}`, 'error');
        ElMessage.error({
            message: `停止失败: ${error.message || '未知错误'}`,
            duration: 5000
        });
    } finally {
        startBtn.disabled = false;
        stopBtn.disabled = true;
        
        // 隐藏进度条
        updateProgress(0, false);
    }
}

    // 显示处理结果的函数
    function displayResults(results) {
        console.log('displayResults函数被调用，参数:', results);
        
        if (!resultsEl) {
            console.error('结果元素不存在，resultsEl:', resultsEl);
            return;
        }
        
        // 清空容器
        resultsEl.innerHTML = '';
        
        addLog('开始显示搜索结果...', 'info');
        
        // 检查results是否为有效数据
        if (!results) {
            console.error('结果数据为空');
            addLog('接收到的数据为空', 'error');
            resultsEl.innerHTML = '<p style="text-align: center; color: #666;">数据为空</p>';
            return;
        }
        
        if (!Array.isArray(results)) {
            console.error('结果数据不是数组，而是:', typeof results);
            addLog('接收到的数据格式无效，不是数组', 'error');
            resultsEl.innerHTML = '<p style="text-align: center; color: #666;">数据格式无效</p>';
            return;
        }
        
        // 创建结果标题
        const resultTitle = document.createElement('h4');
        resultTitle.textContent = `找到 ${results.length} 个匹配结果:`;
        resultsEl.appendChild(resultTitle);
        
        // 添加调试日志
        console.log('显示结果数据:', results);
        results.forEach((result, index) => {
            console.log(`结果 ${index + 1}:`, result);
            if (result.partTitle) {
                console.log(`  - 标题: ${result.partTitle}`);
            } else {
                console.log('  - 未找到标题');
            }
        });
        
        try {
            // 添加JSON数据显示区域
            const jsonDisplay = document.createElement('div');
            jsonDisplay.className = 'json-display';
            
            // 添加JSON标题
            const jsonTitle = document.createElement('h5');
            jsonTitle.textContent = 'JSON数据:';
            jsonTitle.style.margin = '0 0 10px 0';
            jsonTitle.style.color = '#333';
            jsonDisplay.appendChild(jsonTitle);
            
            // 添加JSON内容
            const jsonContent = document.createElement('pre');
            jsonContent.textContent = JSON.stringify(results, null, 2);
            jsonDisplay.appendChild(jsonContent);
            
            // 添加复制按钮
            const copyBtn = document.createElement('button');
            copyBtn.textContent = '复制JSON';
            copyBtn.style.marginTop = '10px';
            copyBtn.style.padding = '5px 10px';
            copyBtn.style.backgroundColor = '#4facfe';
            copyBtn.style.color = 'white';
            copyBtn.style.border = 'none';
            copyBtn.style.borderRadius = '3px';
            copyBtn.style.cursor = 'pointer';
            copyBtn.onclick = function() {
                navigator.clipboard.writeText(JSON.stringify(results, null, 2))
                    .then(() => {
                        ElMessage.success('JSON数据已复制到剪贴板');
                    })
                    .catch(err => {
                        console.error('复制失败:', err);
                        ElMessage.error('复制失败');
                    });
            };
            jsonDisplay.appendChild(copyBtn);
            
            // 添加导出JSON按钮
            const exportBtn = document.createElement('button');
            exportBtn.textContent = '导出JSON';
            exportBtn.className = 'el-button el-button--primary el-button--small';
            exportBtn.style.marginLeft = '10px';
            exportBtn.onclick = exportGovInfoData;
            jsonDisplay.appendChild(exportBtn);
            
            // 确保将JSON显示区域添加到结果元素
            resultsEl.appendChild(jsonDisplay);
            console.log('JSON数据显示区域已添加到结果元素');
            
            // 在控制台打印每个记录的jsonData
            console.log('每个记录的JSON数据:');
            results.forEach((item, index) => {
                console.log(`记录 ${index + 1} JSON数据:`, item);
            });
        } catch (error) {
            console.error('添加JSON显示区域时出错:', error);
            addLog('添加JSON显示区域时出错: ' + error.message, 'error');
        }
        
        // 为每个记录添加单独的JSON数据显示区域并打印到控制台
        results.forEach((item, index) => {
            // 打印每个记录的JSON数据到控制台
            console.log(`记录 ${index + 1} 的JSON数据:`, item);
            // 创建记录容器
            const recordContainer = document.createElement('div');
            recordContainer.className = 'result-item';
            recordContainer.style.marginBottom = '20px';
            
            // 创建记录标题
            const recordTitle = document.createElement('h5');
            recordTitle.textContent = `记录 ${index + 1}: ${item.partTitle || '未命名记录'}`;
            recordTitle.style.margin = '0 0 10px 0';
            recordTitle.style.color = '#333';
            recordContainer.appendChild(recordTitle);
            
            // 创建记录内容表格
            const recordTable = document.createElement('table');
            recordTable.style.width = '100%';
            recordTable.style.borderCollapse = 'collapse';
            recordTable.style.marginBottom = '10px';
            
            // 添加表格行
            const fields = [
                { name: '标题', value: item.title },
                { name: '部分', value: item.part },
                { name: '部分标题', value: item.partTitle },
                { name: '文本索引', value: item.textIndex },
                { name: '日期', value: item.date },
                { name: '摘要', value: item.summary },
                { name: 'PDF链接', value: item.pdfUrl }
            ];
            
            fields.forEach(field => {
                const row = document.createElement('tr');
                row.style.borderBottom = '1px solid #eee';
                
                const nameCell = document.createElement('td');
                nameCell.textContent = field.name;
                nameCell.style.padding = '5px';
                nameCell.style.fontWeight = 'bold';
                nameCell.style.width = '100px';
                
                const valueCell = document.createElement('td');
                valueCell.textContent = field.value || '无';
                valueCell.style.padding = '5px';
                
                row.appendChild(nameCell);
                row.appendChild(valueCell);
                recordTable.appendChild(row);
            });
            
            recordContainer.appendChild(recordTable);
            
            // 创建记录JSON显示区域
            const recordJsonDisplay = document.createElement('div');
            recordJsonDisplay.className = 'json-display';
            recordJsonDisplay.style.marginTop = '10px';
            recordJsonDisplay.style.backgroundColor = '#f8f9fa';
            recordJsonDisplay.style.padding = '10px';
            recordJsonDisplay.style.borderRadius = '5px';
            
            // 添加JSON标题
            const recordJsonTitle = document.createElement('h6');
            recordJsonTitle.textContent = 'JSON数据:';
            recordJsonTitle.style.margin = '0 0 5px 0';
            recordJsonTitle.style.color = '#333';
            recordJsonDisplay.appendChild(recordJsonTitle);
            
            // 添加JSON内容
            const recordJsonContent = document.createElement('pre');
            recordJsonContent.textContent = JSON.stringify(item, null, 2);
            recordJsonContent.style.margin = '0';
            recordJsonContent.style.fontSize = '12px';
            recordJsonDisplay.appendChild(recordJsonContent);
            
            recordContainer.appendChild(recordJsonDisplay);
            
            // 添加到结果区域
            resultsEl.appendChild(recordContainer);
        });
        
        // 按Title分组显示
        const groupedResults = {};
        results.forEach(result => {
            if (!groupedResults[result.title]) {
                groupedResults[result.title] = [];
            }
            groupedResults[result.title].push(result);
        });
        
        // 创建分组显示
        Object.keys(groupedResults).forEach(title => {
            const titleDiv = document.createElement('div');
            titleDiv.className = 'result-group';
            titleDiv.style.marginBottom = '15px';
            
            const titleHeader = document.createElement('h5');
            titleHeader.textContent = `Title ${title}`;
            titleHeader.style.margin = '10px 0';
            titleHeader.style.color = '#4facfe';
            titleDiv.appendChild(titleHeader);
            
            // 创建该Title下的结果列表
            groupedResults[title].forEach(result => {
                const resultItem = document.createElement('div');
                resultItem.className = 'result-item';
                resultItem.style.margin = '10px 0';
                resultItem.style.padding = '10px';
                resultItem.style.border = '1px solid #eee';
                resultItem.style.borderRadius = '5px';
                resultItem.style.backgroundColor = '#f9f9f9';
                
                // 创建结果内容
                let resultContent = `<strong>Part ${result.part}</strong>`;
                if (result.partTitle) {
                    resultContent += `<br><span style="font-weight: bold; color: #333;">${result.partTitle}</span>`;
                }
                if (result.date) {
                    resultContent += `<br><span>Date: ${result.date}</span>`;
                }
                if (result.summary) {
                    resultContent += `<br><span>Summary: ${result.summary.substring(0, 100)}...</span>`;
                }
                if (result.pdfUrl) {
                    resultContent += `<br><a href="${result.pdfUrl}" target="_blank">查看PDF</a>`;
                }
                
                resultItem.innerHTML = resultContent;
                titleDiv.appendChild(resultItem);
            });
            
            resultsEl.appendChild(titleDiv);
        });
        
        // 如果没有结果
        if (results.length === 0) {
            resultsEl.innerHTML = '<p style="text-align: center; color: #666;">未找到匹配的结果</p>';
        }
        
        console.log('displayResults函数执行完成');
    }

    // 数据更新标签页功能
    function fetchLatestData() {
        addLog('正在获取最新数据...');
        // 这里添加获取最新数据的逻辑
        ElMessage.info('正在获取最新数据...');
    }

    function updateDatabase() {
        addLog('正在更新数据库...');
        // 这里添加更新数据库的逻辑
        ElMessage.info('正在更新数据库...');
    }

    // 批量处理标签页功能
    function importFiles() {
        addLog('正在导入文件...');
        // 这里添加导入文件的逻辑
        document.getElementById('processBtn').disabled = false;
        ElMessage.info('文件导入成功');
    }

    function processBatch() {
        addLog('正在处理批量任务...');
        // 这里添加批量处理的逻辑
        document.getElementById('exportBtn').disabled = false;
        ElMessage.info('批量处理完成');
    }

    function exportResults() {
        addLog('正在导出结果...');
        // 这里添加导出结果的逻辑
        ElMessage.success('结果导出成功');
    }
    
    // CEN数据获取函数
    async function startCenScraping() {
        console.log('开始执行startCenScraping函数');
        
        // 初始化控制台监听
        initializeCenConsoleMonitoring();
        
        // 详细检查必要的DOM元素
        if (!cenStartBtn) {
            console.error('cenStartBtn元素不存在');
            addCenLog('错误: 开始按钮元素不存在', 'error');
            return;
        }
        
        if (!cenStopBtn) {
            console.error('cenStopBtn元素不存在');
            addCenLog('错误: 停止按钮元素不存在', 'error');
            return;
        }
        
        if (!cenResults) {
            console.error('cenResults元素不存在');
            addCenLog('错误: 结果显示区域元素不存在', 'error');
            return;
        }
        
        console.log('所有必要DOM元素已确认存在');
        
        cenStartBtn.disabled = true;
        cenStopBtn.disabled = false;
        
        // 清空之前的日志
        if (cenLog) {
            cenLog.innerHTML = '';
        }
        
        addCenLog('开始执行CEN标准更新任务', 'info');
        cenResults.innerHTML = '<p style="text-align: center; color: #666;">获取中，请稍候...</p>';
        updateCenProgress(10);
        
        // 存储Processing提示的引用，以便后续关闭
        let processingMessage = null;
        
        try {
            // 创建Processing提示
            processingMessage = ElMessage.info({
                message: '正在获取CEN更新，请稍候...',
                duration: 0,  // 设置为0表示不会自动关闭
                showClose: true  // 显示关闭按钮
            });
            
            // 更新进度条
            updateCenProgress(30);
            
            addCenLog('调用CEN核心脚本处理数据...', 'info');
            console.log('调用CEN核心脚本，参数:', { isHeadless: cenIsHeadless });
            
            const scriptParams = {
                pluginName: 'info-update',
                script: './cen/cen-core.js',
                args: [cenIsHeadless]
            };
            
            console.log('CEN核心脚本调用参数:', scriptParams);
            
            const result = await pluginAPI.runPluginScript(scriptParams);
            
            console.log('CEN核心脚本返回结果:', result);
            console.log('返回结果类型:', typeof result);
            console.log('返回结果是否包含data字段:', result.hasOwnProperty('data'));
            
            if (result.data) {
                console.log('data字段类型:', typeof result.data);
                console.log('data是否为数组:', Array.isArray(result.data));
                if (Array.isArray(result.data)) {
                    console.log('data数组长度:', result.data.length);
                    console.log('data数组第一项:', result.data[0]);
                }
            }
            
            addCenLog('CEN核心脚本执行完成', result.success ? 'success' : 'error');
            
            // 脚本执行完成后设置进度为80%
            updateCenProgress(80);
            
            if (result.success) {
                // 完成进度条
                updateCenProgress(100);
                
                // 关闭Processing提示
                if (processingMessage) {
                    processingMessage.close();
                }
                
                ElMessage.success({
                    message: 'CEN标准更新获取成功！',
                    duration: 3000
                });
                
                // 显示处理结果
                if (result.data) {
                    console.log('获取到CEN数据:', result.data);
                    if (Array.isArray(result.data)) {
                        addCenLog(`成功获取 ${result.data.length} 条CEN数据记录`, 'success');
                        console.log('准备调用displayCenResults函数显示数据');
                        displayCenResults(result.data);
                        
                        // 数据已在后端自动保存为JSON文件
                        console.log('CEN数据已在后端自动保存为JSON文件');
                        addCenLog('CEN数据已在后端自动保存为JSON文件', 'info');
                        
                        // 启用导出按钮
                if (cenExportBtn) {
                    cenExportBtn.disabled = false;
                }
                    } else {
                        console.error('返回的CEN数据不是数组:', result.data);
                        addCenLog('返回的CEN数据格式不正确，不是数组', 'warning');
                        displayCenResults([]);
                    }
                } else {
                    console.error('未获取到CEN数据记录');
                    addCenLog('未获取到CEN数据记录', 'warning');
                    displayCenResults([]);
                }
                
                // 延迟后隐藏进度条
                setTimeout(() => updateCenProgress(0, false), 1000);
            }
            if (!result.success) {
                console.error('CEN执行失败:', result.error);
                addCenLog(`CEN执行失败: ${result.error}`, 'error');
                throw new Error(result.error);
            }
        } catch (error) {
            // 出错时隐藏进度条
            updateCenProgress(0, false);
            
            // 关闭Processing提示
            if (processingMessage) {
                processingMessage.close();
            }
            
            console.error('CEN发生错误:', error);
            addCenLog(`CEN发生错误: ${error.message}`, 'error');
            
            ElMessage.error({
                message: 'CEN获取失败，请检查日志。',
                duration: 5000,  // 5秒后自动关闭
                showClose: true  // 显示关闭按钮
            });
            
            addCenLog(`CEN搜索失败: ${error.message}`);
            cenResults.innerHTML = '<p style="text-align: center; color: #d32f2f;">CEN搜索失败，请查看日志</p>';
        } finally {
            // 重新启用按钮
            cenStartBtn.disabled = false;
            cenStopBtn.disabled = true;
        }
    }
    
    // 显示CEN筛选结果
    function displayCenResults(data) {
        if (!cenResults || !data || data.length === 0) {
            if (cenResults) {
                cenResults.innerHTML = '<p style="text-align: center; color: #666;">未找到符合条件的数据</p>';
            }
            return;
        }
        
        let html = `
            <div class="results-header">
                <h4>筛选结果 (${data.length} 条记录)</h4>
                <div class="results-stats">
                    <span class="stat-item">目标TC: ${targetTCs.length} 个</span>
                    <span class="stat-item">匹配记录: ${data.length} 条</span>
                </div>
            </div>
            <div class="results-table">
                <table class="table table-striped">
                    <thead>
                        <tr>
                            <th style="width: 20%;">Standard reference</th>
                            <th style="width: 40%;">Title</th>
                            <th style="width: 20%;">Technical body</th>
                            <th style="width: 20%;">Date of Publication</th>
                        </tr>
                    </thead>
                    <tbody>
        `;
        
        data.forEach(item => {
            html += `
                <tr>
                    <td><strong>${item.reference}</strong></td>
                    <td>${item.title}</td>
                    <td><span class="tc-badge">${item.technicalBody}</span></td>
                    <td>${item.publicationDate}</td>
                </tr>
            `;
        });
        
        html += `
                    </tbody>
                </table>
            </div>
        `;
        
        cenResults.innerHTML = html;
    }
    
    // 停止CEN数据获取
    async function stopCenScraping() {
        try {
            addCenLog('正在尝试停止CEN搜索...', 'warning');
            addCenLog('用户请求停止CEN搜索');
            
            // 调用pluginAPI.stopPluginScript方法停止脚本
            const taskId = pluginAPI.getCurrentTaskId();
            console.log(`当前CEN任务ID: ${taskId || '无'}`);
            
            if (taskId) {
                console.log(`正在停止CEN任务: ${taskId}`);
                addCenLog(`正在停止CEN任务: ${taskId}`);
                const result = await pluginAPI.stopPluginScript();
                console.log('停止CEN脚本结果:', result);
                
                if (result.success) {
                    addCenLog('CEN搜索已成功停止', 'success');
                    ElMessage.success({
                        message: 'CEN搜索已停止',
                        duration: 3000
                    });
                } else {
                    addCenLog(`停止CEN搜索失败: ${result.error || '未知错误'}`, 'error');
                    ElMessage.error({
                        message: `停止CEN搜索失败: ${result.error || '未知错误'}`,
                        duration: 5000
                    });
                }
            } else {
                console.warn('没有正在运行的CEN搜索任务');
                addCenLog('没有找到正在运行的CEN搜索任务', 'warning');
                ElMessage.warning({
                    message: '没有正在运行的CEN搜索任务',
                    duration: 3000
                });
                
                // 即使没有任务，也重置按钮状态和隐藏进度条
                cenStartBtn.disabled = false;
                cenStopBtn.disabled = true;
                updateCenProgress(0, false);
                return;
            }
        } catch (error) {
            console.error('停止CEN搜索时发生错误:', error);
            addCenLog(`停止CEN失败: ${error.message || '未知错误'}`, 'error');
            ElMessage.error({
                message: `停止CEN失败: ${error.message || '未知错误'}`,
                duration: 5000
            });
        } finally {
            cenStartBtn.disabled = false;
            cenStopBtn.disabled = true;
            
            // 隐藏进度条
            updateCenProgress(0, false);
            
            // 清理控制台监听
            cleanupCenConsoleMonitoring();
        }
    }
    
    // 导出CEN数据
    function exportCenData() {
        if (!cenFilteredData || cenFilteredData.length === 0) {
            ElMessage.warning('没有可导出的数据');
            return;
        }
        
        try {
            // 创建CSV内容
            const headers = ['标准编号', '标题', '技术委员会', '发布日期'];
            let csvContent = headers.join(',') + '\n';
            
            cenFilteredData.forEach(item => {
                const row = [
                    `"${item.reference}"`,
                    `"${item.title}"`,
                    `"${item.technicalBody}"`,
                    `"${item.publicationDate}"`
                ];
                csvContent += row.join(',') + '\n';
            });
            
            // 创建下载链接
            const blob = new Blob([csvContent], { type: 'text/csv;charset=utf-8;' });
            const link = document.createElement('a');
            const url = URL.createObjectURL(blob);
            link.setAttribute('href', url);
            link.setAttribute('download', `CEN_Standards_${new Date().toISOString().split('T')[0]}.csv`);
            link.style.visibility = 'hidden';
            document.body.appendChild(link);
            link.click();
            document.body.removeChild(link);
            
            addCenLog(`成功导出 ${cenFilteredData.length} 条记录到CSV文件`, 'success');
            ElMessage.success('CEN数据导出成功');
            
        } catch (error) {
            addCenLog(`导出数据时发生错误: ${error.message}`, 'error');
            ElMessage.error('导出CEN数据失败');
        }
    }
    
    // 导出GovInfo数据为JSON文件
    function exportGovInfoData() {
        addLog('正在导出GovInfo数据...', 'info');
        
        try {
            // 获取结果数据
            const resultsEl = document.getElementById('results');
            if (!resultsEl) {
                ElMessage.warning({
                    message: '结果元素不存在',
                    duration: 3000
                });
                addLog('结果元素不存在', 'warning');
                return;
            }
            
            // 检查是否有JSON数据
            const jsonDisplay = resultsEl.querySelector('.json-display pre');
            if (!jsonDisplay || !jsonDisplay.textContent) {
                ElMessage.warning({
                    message: '没有可导出的JSON数据',
                    duration: 3000
                });
                addLog('没有可导出的JSON数据', 'warning');
                return;
            }
            
            // 获取JSON数据
            const jsonString = jsonDisplay.textContent;
            
            // 创建Blob对象
            const blob = new Blob([jsonString], { type: 'application/json' });
            
            // 创建下载链接
            const url = URL.createObjectURL(blob);
            const a = document.createElement('a');
            a.href = url;
            a.download = `govinfo_results_${new Date().toISOString().slice(0, 10)}.json`;
            document.body.appendChild(a);
            a.click();
            document.body.removeChild(a);
            URL.revokeObjectURL(url);
            
            ElMessage.success({
                message: 'GovInfo数据导出成功',
                duration: 3000
            });
            addLog('GovInfo数据导出成功', 'success');
        } catch (error) {
            console.error('导出GovInfo数据时发生错误:', error);
            ElMessage.error({
                message: `导出GovInfo数据时发生错误: ${error.message || '未知错误'}`,
                duration: 5000
            });
            addLog(`导出GovInfo数据时发生错误: ${error.message || '未知错误'}`, 'error');
        }
    }

    // Python环境检查函数
    async function checkPythonEnvironmentOnStartup() {
        try {
            addLog('开始检查Python环境...', 'info');
            
            // 调用pythonEnvironmentService的checkAndDownloadPythonEnvironment方法
            if (pyAPI && pyAPI.checkAndDownloadPythonEnvironment) {
            const result = await pyAPI.checkAndDownloadPythonEnvironment('sofaData-process');
            
            if (result.success && result.installed) {
                addLog(`Python环境检查完成 - 版本: ${result.version}, pip: ${result.pipInstalled ? '已安装' : '未安装'}`, 'success');
            } else {
                addLog(`Python环境检查失败: ${result.message}`, 'error');
            }
            } else {
            addLog('pyAPI不可用，无法检查Python环境', 'error');
            }
        } catch (error) {
            addLog(`Python环境检查出错: ${error.message}`, 'error');
            console.error('Python环境检查出错:', error);
        }
    }

    // 设置Python脚本日志监听器
    function setupPythonLogListeners() {
        // 监听Python脚本输出
        window.pyAPI.onPythonLogOutput((data) => {
            addLog(`[Python] ${data}`, 'info');
        });

        // 监听Python脚本结束
        window.pyAPI.onPythonProcessEnded((data) => {
            if (data.code === 0) {
                addLog('Python脚本执行完成', 'info');
            } else {
                addLog(`Python脚本执行失败，退出码: ${data.code}`, 'error');
            }
        });
    }
    
    // 页面加载完成后的初始化和事件绑定
    window.addEventListener('load', async function() {
        addLog('信息更新工具集前端界面已加载');
        addLog('请选择需要使用的功能标签页');
        
        // 检查Python环境
        await checkPythonEnvironmentOnStartup();
        
        // 设置Python脚本日志监听器
        setupPythonLogListeners();
        
        // 启动控制台监控，接收终端输出
        await consoleAPI.startConsoleMonitoring();
        
        // 监听控制台日志
        await consoleAPI.onConsoleLog((log) => {
            addLog(`[终端] ${log.message}`, log.level === 'error' ? 'error' : 
                   log.level === 'warn' ? 'warning' : 'info');
        });
        
        // 监听批量日志
        await consoleAPI.onConsoleLogsBatch((logs) => {
            logs.forEach(log => {
                addLog(`[终端] ${log.message}`, log.level === 'error' ? 'error' : 
                       log.level === 'warn' ? 'warning' : 'info');
            });
        });
        
        // 检查是否默认显示Technical Update标签页
        const activeTab = document.querySelector('.tab-content.active');
        if (activeTab && activeTab.id === 'data-compare-content') {
            setTimeout(() => {
                loadTechUpdateModule();
            }, 500);
        }
        
        // 初始化时间框架选择器
        const timeframeSelect = document.getElementById('timeframeSelect');
        if (timeframeSelect) {
            // 设置默认选中项为'Past 7 Days'
            const defaultTimeframe = 'Past 7 Days';
            for (let i = 0; i < timeframeSelect.options.length; i++) {
                if (timeframeSelect.options[i].value === defaultTimeframe) {
                    timeframeSelect.selectedIndex = i;
                    break;
                }
            }
            
            addLog(`已设置默认时间框架: ${defaultTimeframe}`, 'info');
            
            // 添加时间框架选择器的变更事件监听器
            timeframeSelect.addEventListener('change', function() {
                const selectedValue = timeframeSelect.value;
                addLog(`已选择时间框架: ${selectedValue}`, 'info');
                ElMessage.info({
                    message: `已选择时间框架: ${selectedValue}`,
                    duration: 2000
                });
            });
        }
        
        // 启用CFR搜索标签页的开始按钮
        if (startBtn) {
            startBtn.disabled = false;
        }
        
        // 绑定标签页切换事件
        const tabs = document.querySelectorAll('.tab');
        tabs.forEach(tab => {
            tab.addEventListener('click', () => {
                // 移除所有标签页和内容的活动状态
                document.querySelectorAll('.tab').forEach(t => t.classList.remove('active'));
                document.querySelectorAll('.tab-content').forEach(c => c.classList.remove('active'));
                
                // 添加当前标签页和对应内容的活动状态
                tab.classList.add('active');
                const tabId = tab.getAttribute('data-tab');
                selectedTab.value = tabId;
                document.getElementById(`${tabId}-content`).classList.add('active');
                
                // 如果是Technical Update标签页，加载相关功能
                if (tabId === 'data-compare') {
                    setTimeout(() => {
                        loadTechUpdateModule();
                    }, 200);
                }
            });
        });
    });

    // 绑定按钮事件
    if (startBtn) {
        startBtn.addEventListener('click', startScraping);
    }

    if (stopBtn) {
        stopBtn.addEventListener('click', stopScraping);
    }

    // ASTM更新标签页按钮事件已移至astm-update.js文件中
    // 这里保留代码以防止潜在的引用错误
    const fetchDataBtn = document.getElementById('fetchDataBtn');
    const updateDataBtn = document.getElementById('updateDataBtn');

    if (fetchDataBtn) {
        fetchDataBtn.addEventListener('click', fetchLatestData);
    }

    if (updateDataBtn) {
        updateDataBtn.addEventListener('click', updateDatabase);
    }

    // 绑定批量处理标签页按钮事件
    const importBtn = document.getElementById('importBtn');
    const processBtn = document.getElementById('processBtn');
    const exportBtn = document.getElementById('exportBtn');

    if (importBtn) {
        importBtn.addEventListener('click', importFiles);
    }

    if (processBtn) {
        processBtn.addEventListener('click', processBatch);
    }

    if (exportBtn) {
        exportBtn.addEventListener('click', exportResults);
    }
    
    // CEN功能按钮事件绑定
    if (cenStartBtn) {
        cenStartBtn.addEventListener('click', startCenScraping);
    }
    
    if (cenStopBtn) {
        cenStopBtn.addEventListener('click', stopCenScraping);
    }
    
    if (cenExportBtn) {
        cenExportBtn.addEventListener('click', exportCenData);
    }
    
    // 绑定检测数据源按钮事件（独立于Technical Update模块）
    const checkDataSourcesBtn = document.getElementById('checkDataSourcesBtn');
    if (checkDataSourcesBtn) {
        checkDataSourcesBtn.addEventListener('click', function() {
            console.log('检测数据源按钮被点击');
            
            // 确保Technical Update模块已加载
            if (window.TechUpdate && window.TechUpdate.checkDataSources) {
                window.TechUpdate.checkDataSources();
            } else {
                console.log('Technical Update模块未加载，尝试加载模块');
                loadTechUpdateModule();
                
                // 等待模块加载完成后执行检测
                setTimeout(() => {
                    if (window.TechUpdate && window.TechUpdate.checkDataSources) {
                        console.log('模块加载完成，执行数据源检测');
                        window.TechUpdate.checkDataSources();
                    } else {
                        console.error('模块加载失败，无法执行数据源检测');
                        ElMessage.error('Technical Update模块加载失败，请刷新页面重试');
                    }
                }, 1500);
            }
        });
        console.log('检测数据源按钮事件已绑定');
    } else {
        console.warn('checkDataSourcesBtn 元素未找到');
    }
    
    // 初始化EU Commission UI（确保在DOM加载后执行）
    function initializeEUCommissionIntegration() {
        console.log('开始集成EU Commission UI...');
        
        // 检查EU Commission UI是否已加载
        if (window.euCommissionUI) {
            console.log('EU Commission UI已加载，直接初始化元素');
            // 确保元素已经初始化
            if (window.euCommissionUI.initializeElements) {
                window.euCommissionUI.initializeElements();
                console.log('EU Commission UI元素初始化完成');
            }
            return;
        }
        
        // 等待EU Commission UI脚本加载完成
        let checkCount = 0;
        const maxChecks = 50; // 最多检查5秒
        
        const checkEUCommissionUI = () => {
            checkCount++;
            console.log(`检查EU Commission UI加载状态 (${checkCount}/${maxChecks})`);
            
            if (window.euCommissionUI) {
                console.log('EU Commission UI加载完成，开始初始化元素');
                
                // 确保元素已经初始化
                if (window.euCommissionUI.initializeElements) {
                    window.euCommissionUI.initializeElements();
                    console.log('EU Commission UI元素初始化完成');
                } else {
                    console.warn('EU Commission UI缺少initializeElements方法');
                }
                
                // 验证关键元素是否存在
                const startBtn = document.getElementById('eu-start-btn');
                const resultsContainer = document.getElementById('eu-results');
                console.log('EU Commission关键元素检查:');
                console.log('- 开始按钮:', startBtn ? '✓' : '✗');
                console.log('- 结果容器:', resultsContainer ? '✓' : '✗');
                
                return;
            }
            
            if (checkCount < maxChecks) {
                setTimeout(checkEUCommissionUI, 100);
            } else {
                console.error('EU Commission UI加载超时，可能需要手动刷新页面');
                console.log('当前window对象上的euCommissionUI:', window.euCommissionUI);
            }
        };
        
        checkEUCommissionUI();
    }
    
    // 在DOM加载完成后初始化EU Commission集成
    if (document.readyState === 'loading') {
        document.addEventListener('DOMContentLoaded', initializeEUCommissionIntegration);
    } else {
        initializeEUCommissionIntegration();
    }
    
    // 加载Technical Update模块
    // Technical Update 生成按钮处理函数
    function handleTechUpdateGenerate() {
        console.log('Technical Update: 开始生成报告');
        console.log('window.TechUpdate:', window.TechUpdate);
        console.log('window.techUpdateLoaded:', window.techUpdateLoaded);
        
        // 确保 TechUpdate 模块已加载
        if (!window.TechUpdate) {
            console.error('Technical Update 模块未加载，尝试加载模块');
            
            // 尝试加载模块
            loadTechUpdateModule();
            
            // 等待模块加载完成后再次尝试
            setTimeout(() => {
                if (window.TechUpdate && window.TechUpdate.generateReport) {
                    console.log('模块加载完成，调用 generateReport');
                    window.TechUpdate.generateReport();
                } else {
                    console.error('模块加载失败');
                    ElMessage.error('Technical Update 模块加载失败，请检查控制台错误信息或刷新页面重试');
                }
            }, 1500);
            return;
        }
        
        // 调用生成报告功能
        if (window.TechUpdate.generateReport) {
            window.TechUpdate.generateReport();
        } else {
            console.error('generateReport 方法不存在');
            ElMessage.error('生成报告功能不可用，请检查模块加载状态');
        }
    }
    
    // Technical Update 重置按钮处理函数
    function handleTechUpdateReset() {
        console.log('Technical Update: 开始重置');
        
        // 确保 TechUpdate 模块已加载
        if (!window.TechUpdate) {
            console.error('Technical Update 模块未加载');
            ElMessage.error('Technical Update 模块未加载，请刷新页面重试');
            return;
        }
        
        // 调用重置功能
        if (window.TechUpdate.reset) {
            window.TechUpdate.reset();
        } else {
            console.error('reset 方法不存在');
            ElMessage.error('重置功能不可用，请检查模块加载状态');
        }
    }
    
    // 将函数暴露到全局作用域
    window.handleTechUpdateGenerate = handleTechUpdateGenerate;
    window.handleTechUpdateReset = handleTechUpdateReset;

    // 清空日志功能
    function clearLog(logElementId) {
        const logElement = document.getElementById(logElementId);
        if (logElement) {
            logElement.innerHTML = '等待操作...';
            console.log(`已清空 ${logElementId} 的日志`);
        }
    }

    // 绑定清空日志按钮事件
    const clearLogBtn = document.getElementById('clear-log-btn');
    const clearAstmLogBtn = document.getElementById('clear-astm-log-btn');
    const clearCenLogBtn = document.getElementById('clear-cen-log-btn');
    const clearEuLogBtn = document.getElementById('clear-eu-log-btn');

    if (clearLogBtn) {
        clearLogBtn.addEventListener('click', () => clearLog('log'));
    }

    if (clearAstmLogBtn) {
        clearAstmLogBtn.addEventListener('click', () => clearLog('astm-log'));
    }

    if (clearCenLogBtn) {
        clearCenLogBtn.addEventListener('click', () => clearLog('cen-log'));
    }

    if (clearEuLogBtn) {
        clearEuLogBtn.addEventListener('click', () => clearLog('eu-log'));
    }

    const clearTechUpdateLogBtn = document.getElementById('clear-tech-update-log-btn');
    if (clearTechUpdateLogBtn) {
        clearTechUpdateLogBtn.addEventListener('click', () => clearLog('tech-update-log'));
    }

    function loadTechUpdateModule() {
        console.log('开始加载 Technical Update 模块');
        
        // 检查是否已经加载过
        if (window.techUpdateLoaded) {
            console.log('Technical Update 模块已加载，直接初始化');
            // 如果已经加载过，直接初始化
            if (window.TechUpdate && window.TechUpdate.init) {
                window.TechUpdate.init();
                console.log('Technical Update 模块重新初始化完成');
            } else {
                console.error('Technical Update 对象不存在或缺少 init 方法');
            }
            return;
        }
        
        // 动态加载tech-update.js
        const script = document.createElement('script');
        
        // 尝试多种路径解析方式
        let scriptPath;
        
        // 方式1: 相对于当前页面的路径
        const currentPath = window.location.pathname;
        if (currentPath.includes('info-update')) {
            scriptPath = './tech-update/tech-update.js';
        } else {
            // 方式2: 基于当前目录的绝对路径
            const basePath = currentPath.substring(0, currentPath.lastIndexOf('/'));
            scriptPath = basePath + '/tech-update/tech-update.js';
        }
        
        script.src = scriptPath;
        console.log('当前页面路径:', currentPath);
        console.log('尝试加载脚本路径:', script.src);
        script.onload = function() {
            window.techUpdateLoaded = true;
            console.log('Technical Update 脚本文件加载成功');
            // 确保在脚本加载完成后初始化
            setTimeout(() => {
                if (window.TechUpdate && window.TechUpdate.init) {
                    console.log('准备初始化 Technical Update 模块');
                    window.TechUpdate.init();
                    console.log('Technical Update 模块初始化完成');
                } else {
                    console.error('Technical Update 对象不存在或缺少 init 方法');
                    console.log('window.TechUpdate:', window.TechUpdate);
                }
            }, 100);
        };
        script.onerror = function(error) {
            console.error('加载 Technical Update 模块失败:', error);
            console.error('失败的脚本路径:', script.src);
            
            // 尝试备用路径
            const backupScript = document.createElement('script');
            const backupPath = scriptPath.includes('./') ? 'tech-update/tech-update.js' : './tech-update/tech-update.js';
            backupScript.src = backupPath;
            console.log('尝试备用脚本路径:', backupScript.src);
            
            backupScript.onload = function() {
                window.techUpdateLoaded = true;
                console.log('备用路径加载成功');
                setTimeout(() => {
                    if (window.TechUpdate && window.TechUpdate.init) {
                        console.log('准备初始化 Technical Update 模块');
                        window.TechUpdate.init();
                        console.log('Technical Update 模块初始化完成');
                    } else {
                        console.error('Technical Update 对象不存在或缺少 init 方法');
                    }
                }, 100);
            };
            
            backupScript.onerror = function() {
                console.error('备用路径也加载失败');
                ElMessage.error('Technical Update 模块脚本加载失败，请检查文件路径');
            };
            
            document.head.appendChild(backupScript);
        };
        document.head.appendChild(script);
        console.log('Technical Update 脚本标签已添加到页面');
    }
}